package com.hss.nestscroll.NewsDetail;

import android.content.Context;
import android.support.annotation.Nullable;
import android.support.v4.view.NestedScrollingParent;
import android.support.v4.view.NestedScrollingParentHelper;
import android.support.v7.widget.LinearLayoutCompat;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.ViewTreeObserver;
import android.widget.ImageView;
import android.widget.LinearLayout;
import com.hss.recyclerviewtest.R;
public class MyNestScrollParent extends LinearLayout implements NestedScrollingParent{
    final  String TAG = "MyNestScrollParent";
    private NestedScrollingParentHelper mParentHelper;
    private int mImgHeight;


    public MyNestScrollParent(Context context) {
        this(context, null);
    }

    public MyNestScrollParent(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public MyNestScrollParent(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mParentHelper = new NestedScrollingParentHelper(this);
    }
    ImageView imageView = null;

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
          imageView = (ImageView) findViewById(R.id.imageview);
        imageView.getViewTreeObserver().addOnGlobalLayoutListener(globalLayoutListener);
    }

    ViewTreeObserver.OnGlobalLayoutListener globalLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
        @Override
        public void onGlobalLayout() {
            if (mImgHeight <= 0){
                mImgHeight = imageView.getHeight();

            }
            imageView.getViewTreeObserver().removeOnGlobalLayoutListener(globalLayoutListener);
        }
    };

    /**
     *例如我们想要把所有的y轴的滑动事件都消耗掉，那么就让consumed[1] = dy;
     * 这样子控件会在父控件的这个方法执行后重新计算还剩余多少可以供自己用，
     * 如果父控件的consumed[1] = dy，那么子控件的剩下的就是dy-consumed[1]=0，也就是不进行任何滑动处理了。
     * 例如我们可以让consumed[1] = dy/2，这样我们手指滑动时父控件和子控件各滑动一半，
     * 这在很多场景下也会使用。在本例中我们使consumed[1] = dy，
     * 什么时候用呢？那就是我们刚才说的逻辑：当向上滚动时（dy>0），上面的图片可见的时候(getScrollY() < mImgHeight)
     * 最外面的Parent滚动，如果图片不可见了，
     * 那么外面的Parent不要滚动，留下那个title显示，接着里面的Child滚动就可以了；当向下滚动时(dy < 0)，
     * Child滚动到最上面的时候(target.getScrollY() <= 0)
     * 让Parent滚动就可以了。
     *
     * @param target  target就是内部嵌套的View，这里就是我们的Child，
     * @param dx  dx是x方向的滑动偏移，
     * @param dy  dy是y方向的滑动偏移，
     * @param consumed      consumed的含义是消耗，它是一个长度是2的int数组，consumed[0]代表x轴，consumed[1]代表y轴。
     */
    @Override
    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
        Log.e(TAG, target.toString());
        boolean isImageViewVisiable = (dy >0 && getScrollY() <mImgHeight ) || (dy<0&&target.getScrollY() <=0);
        if (isImageViewVisiable){
            consumed[1]=dy;
            scrollBy(0,dy);
        }
    }

    @Override
    public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
        super.onNestedScroll(target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed);
    }

    @Override
    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
        return true;
    }
//，我们直接交给助手来处理就好了，
    @Override
    public void onNestedScrollAccepted(View child, View target, int axes) {
        mParentHelper.onNestedScrollAccepted(child, target, axes);
    }

    /**
     * 复写就是为了自己滚动的一个校正。
     * @param x
     * @param y
     */
    @Override
    public void scrollTo(int x, int y) {
        if (y > mImgHeight){
            y = mImgHeight;
        }
        if (y<0){
            y = 0;
        }
        super.scrollTo(x, y);
    }
}
